{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Автор: Петухов Дмитрий*<br />\n",
    "*Дата: 17.04.2018*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "<img src=\"../../img/jigsaw.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "# Обнаружение и классификация недопустимых комментариев на Википедии"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Часть 1. Описание набора данных и признаков"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Нередко обсуждение какой-либо темы на популярных сайтах скатывается во взаимные оскорбления и угрозы, что является недопустимым с точки зрения норм этики, морали и человеческого общения, а также деструктивно влияет на саму обсуждаемую тему. Люди просто перестают общаться, видя такое в комментариях. Данная проблема очень актуальна для Википедии. Каждая статья и её правки активно обсуждаются, и это общение бывает иногда не совсем корректным со стороны некоторых пользователей. Необходимо выявлять такие комментарии и удалять их, чтобы обсуждения были в рамках норм человеческого общения, не было переходов на личности и взаимных оскорблений."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Источник данных"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В проекте используются данные из соревнования на платформе Kaggle <a href=\"https://www.kaggle.com/c/jigsaw-toxic-comment-classification-challenge\">\"Toxic Comment Classification Challenge\"</a>. Компания <a href=\"https://jigsaw.google.com/\">\"Jigsaw\"</a> (подразделение Google), занимающаяся исследованиями в области онлайн-общения пользователей, разместила <a href=\"https://www.kaggle.com/c/jigsaw-toxic-comment-classification-challenge/data\">данные</a>, содержащие корпус размеченных комментариев из Википедии."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Цели и задачи"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Необходимо определить с какой вероятностью каждый комментарий может быть отнесён к одному из следующих классов (целевая переменная):\n",
    "\n",
    "1 - язвительный<br>\n",
    "2 - издевательский<br>\n",
    "3 - непристойная лексика<br>\n",
    "4 - угроза<br>\n",
    "5 - оскорбление<br>\n",
    "6 - личная неприязнь<br>\n",
    "\n",
    "В отличие от обычной постановки задачи классификации (multiclass), в данном случае один комментарий может с той или иной вероятностью принадлежать одновременно к нескольким классам (multilabel). Ценность такой задачи заключается в том, что в дальнейшем решение можно адаптировать под любую интернет-платформу и успешно использовать для пресечения оскорблений и перехода на личности."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Описание набора данных"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Представленные данные содержат два признака:\n",
    "\n",
    "<b>'id'</b> - id комментария<br>\n",
    "<b>'comment_text'</b> - текст комментария\n",
    "\n",
    "Целевая переменная представлена шестью векторами-столбцами. Каждый из них содержит значения 0 или 1 в зависимости от того, принадлежит ли комментарий к данному классу или нет:\n",
    "\n",
    "<b>'toxic'</b> - язвительный комментарий<br>\n",
    "<b>'severe_toxic'</b> - издевательский комментарий<br>\n",
    "<b>'obscene'</b> - комментарий содержит непристойную лексику<br>\n",
    "<b>'threat'</b> - комментарий содержит угрозы<br>\n",
    "<b>'insult'</b> - оскорбительный комментарий<br>\n",
    "<b>'identity_hate'</b> - комментарий содержит признаки личной неприязни<br>\n",
    "\n",
    "Следует заметить, что разметка данных осуществлялась разными людьми с использованием краудсорсинга, поэтому в той или иной степени классы целевой переменной имеют частично субъективный характер."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Часть 2. Первичный анализ данных"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Импорт библиотек"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# базовые библиотеки\n",
    "import pandas as pd \n",
    "import numpy as np\n",
    "\n",
    "# sklearn библиотеки\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer, CountVectorizer, ENGLISH_STOP_WORDS\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.metrics import roc_auc_score\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "# NLP библиотеки\n",
    "import string\n",
    "import re    \n",
    "\n",
    "# библиотеки визуализации данных\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "%matplotlib inline\n",
    "\n",
    "#scipy\n",
    "from scipy.sparse import csr_matrix, hstack\n",
    "from scipy import sparse\n",
    "\n",
    "#вспомогательные библиотеки\n",
    "from PIL import Image\n",
    "import pprint\n",
    "import time\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "color = sns.color_palette(\"Set2\", 10)\n",
    "sns.set_style(\"whitegrid\")\n",
    "sns.set_context(\"paper\")\n",
    "sns.palplot(color)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Первичный анализ данных"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Посмотрим на десять случайных объектов обучающего и тестового датасетов и выведем общее количество объектов в них. Также посмотрим на число уникальных значений в признаке id комментария."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train = pd.read_csv('data/train.csv')\n",
    "test = pd.read_csv('data/test.csv')\n",
    "print('Обучающая выборка содержит {} объект'.format(len(train)))\n",
    "print('Число уникальных значений в признаке id: {}\\n'.format(train.id.nunique()))\n",
    "train.sample(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Тестовая выборка содержит {} объекта'.format(len(test)))\n",
    "print('Число уникальных значений в признаке id: {}'.format(test.id.nunique()))\n",
    "test.sample(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как описывалось выше, тренировочные данные содержат два объясняющих признака и шесть вектор-столбцов целевой переменной. Аналогичная ситуация в тестовой выборке за исключением того, что в ней удалена целевая переменная. Всего - 159 571 комментарий в обучающей выборке и 153 164 комментариев в тестовой. Число уникальных значений в признаке id комментария в каждой выборке соответствует количеству объектов. Это хэш id комментария и он бесполезен в нашем случае. Удалим его. Таким образом, остается один единственный объясняющий признак - текст комментария. Следует обратить внимание ещё на два момента:\n",
    "1. Как минимум в тестовой выборке присутствуют неанглоязычные комментарии. \n",
    "2. Текстовые данные сильно 'замусорены'\n",
    "\n",
    "Теперь посмотрим, есть ли пропущенные значения в данных."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train.drop('id', axis=1, inplace=True)\n",
    "null_count = train.isnull().sum(axis=0).reset_index()\n",
    "null_count.columns = ['col_name', 'null_count']\n",
    "null_count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test.drop('id', axis=1, inplace=True)\n",
    "null_count = test.isnull().sum(axis=0).reset_index()\n",
    "null_count.columns = ['col_name', 'null_count']\n",
    "null_count"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Пропусков нет и это хорошая новость. Тренировочная и тестовая выборки имеют примерно одинаковое количество объектов.<br>\n",
    "Посмотрим, как распределены классы целевой переменной в обучающей выборке. Следует помнить, что один объект может принадлежать к нескольким классам."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(12,8))\n",
    "ax1 = sns.barplot(train.describe().loc['mean'].index, train.describe().loc['mean'])\n",
    "plt.ylabel('Доля объектов от общего числа', fontsize=12)\n",
    "plt.xlabel('Класс', fontsize=12)\n",
    "plt.title('Распределение классов в обучающей выборке', fontsize=15)\n",
    "plt.xticks(rotation=45, fontsize=11)\n",
    "plt.grid(False)\n",
    "\n",
    "for p in ax1.patches:\n",
    "    x=p.get_bbox().get_points()[:,0]\n",
    "    y=p.get_bbox().get_points()[1,1]\n",
    "    ax1.annotate('{0:.2f}%'.format(p.get_height()*100), (x.mean(), y), ha='center', va='bottom');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Часть 3. Первичный визуальный анализ данных"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для дальнейшего визуального анализа добавим следующие признаки в обучающую выборку:<br>\n",
    "<br>\n",
    "<b>'clean'</b> - Нормальный комментарий (не принадлежит ни к одному из классов)<br>\n",
    "<b>'class_sum'</b> - Число классов, к которым отнесён комментарий<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_cols = ['toxic', 'severe_toxic', 'obscene', 'threat', 'insult', 'identity_hate']\n",
    "class_sum = train.loc[:,y_cols].sum(axis=1)\n",
    "train['class_sum'] = class_sum\n",
    "train['clean'] = (class_sum==0).astype(int)\n",
    "train.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Баланс классов"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Далее посмотрим на число классов в обучающей выборке."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class_counts = train.loc[:, y_cols+['clean']].sum()\n",
    "plt.figure(figsize=(10,6))\n",
    "ax1 = sns.barplot(class_counts.index, class_counts, color=color[2], alpha=0.8)\n",
    "plt.ylabel('Количество объектов', fontsize=12)\n",
    "plt.xlabel('Класс', fontsize=12)\n",
    "plt.title('Распределение классов в обучающей выборке', fontsize=15)\n",
    "plt.xticks(fontsize=11)\n",
    "plt.grid(False)\n",
    "\n",
    "for p in ax1.patches:\n",
    "    x=p.get_bbox().get_points()[:,0]\n",
    "    y=p.get_bbox().get_points()[1,1]\n",
    "    ax1.annotate('{:.0f}'.format(p.get_height()), (x.mean(), y), ha='center', va='bottom')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Видно, что в данных присутствует сильный дисбаланс классов. И это нормальная жизненная ситуация, подавляющее большинство людей предпочитают уважительное и конструктивное общение. Тем более на таком сайте как Википедия. Обратим внимание на то, что общая сумма объектов больше 153 164 и это тоже нормально, так как один и тот же комментарий может относится к нескольким классам.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Количество классов у одного комментария"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(10,6))\n",
    "ax1 = sns.barplot(train.class_sum.value_counts().index, train.class_sum.value_counts(), color=color[1], alpha=0.8)\n",
    "plt.ylabel('Количество комментариев', fontsize=12)\n",
    "plt.xlabel('Количество классов', fontsize=12)\n",
    "plt.title('Количество классов, приходящихся на комментарий', fontsize=15)\n",
    "plt.xticks(fontsize=11)\n",
    "plt.grid(False)\n",
    "\n",
    "for p in ax1.patches:\n",
    "    x=p.get_bbox().get_points()[:,0]\n",
    "    y=p.get_bbox().get_points()[1,1]\n",
    "    ax1.annotate('{:.0f}'.format(p.get_height()), (x.mean(), y), ha='center', va='bottom')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Нормальных комментариев, не относящихся ни к одному из классов ровно столько же, сколько и на предыдущем графике. Это очевидно. Комментариев, одновременно содержащих в себе язвительность, издевку, обсценную лексику, оскорбления, угрозы и личную неприязнь, то есть комментарий имеет признаки каждого класса, ничтожно мало - примерно 0.02%. Больше всего комментариев относится только к какому-то одному определенному классу. В то же время довольно большое число объектов относится к двум, трем и четырем классам одновременно. Последняя особенность довольно интересна, наверняка это близкие по \"духу\" классы. Проверим это предположение визуально, но сначала давайте посмотрим на пример комментария, содержащего признаки всех шести классов."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train[train.class_sum==6].reset_index(drop=True).loc[0,'comment_text']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Да, это действительно эталон недопустимого комментария. Кстати, на этом примере хороша видна одна особенность ругани в интернете - люди переходят на капслок. Возможно, это можно будет использовать в дальнейшем."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Совместные появления классов в комментариях"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "heat = np.zeros((6,6))\n",
    "for idx,col in enumerate(y_cols):\n",
    "    if col=='severe_toxic':\n",
    "        heat[idx,1:]=train[train[col]==1].groupby('class_sum')['class_sum'].count().values\n",
    "    else:\n",
    "        heat[idx,:]=train[train[col]==1].groupby('class_sum')['class_sum'].count().values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(12,8))\n",
    "plt.title('Корреляция класса и числа классов в комментарии', fontsize=20)\n",
    "ax = sns.heatmap(heat, cmap='viridis', fmt='.0f', xticklabels=[1,2,3,4,5,6], yticklabels=y_cols, annot=True)\n",
    "ax.set(xlabel='Число классов в комментарии', ylabel='Класс')\n",
    "ax.tick_params(labelsize=10)\n",
    "plt.yticks(rotation=0, fontsize=11)\n",
    "plt.xticks(fontsize=11);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Довольно интересные результаты. Во-первых, нет ни одного комментария, содержащего только один класс \"severe_toxic\". Во-вторых, подавляющее большинство комментариев с одним классом отнесены к \"toxic\". В-третьих, комментарии с признаками трех классов чаще всего относятся к: \"toxic\", \"insult\", \"obscene\". Это объяснимо, язвительность, мат и оскорбления всегда идут рука об руку. И еще одно наблюдение, которое непросто объяснить - классы \"severe_toxic\" и \"identity_hate\" встречаются чаще всего в комментариях с признаками четырех классов.</br> \n",
    "Посмотрим теперь на это под другим углом - как часто определенный класс появляется с другими классами.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, axes = plt.subplots(nrows=3, ncols=2, figsize=(16, 12))\n",
    "fig.suptitle('Совместные появления классов в комментариях',fontsize = 18)\n",
    "\n",
    "for idx, col in  enumerate(y_cols): \n",
    "    temp_list = y_cols[:]\n",
    "    temp_list.remove(col)\n",
    "    sub_series = train[train[col]==1].loc[:,temp_list].sum()\n",
    "    ax1 = sns.barplot(sub_series.index, sub_series, color=color[idx], alpha=0.8, ax=axes[idx // 2][idx % 2])\n",
    "    ax1.tick_params(labelsize=10)\n",
    "    ax1.set_title(col+' ({} комментариев)'.format(train.loc[:,col].sum()), fontsize= 12)\n",
    "    ax1.set_ylabel('Число совместных появлений')\n",
    "    for p in ax1.patches:\n",
    "        x=p.get_bbox().get_points()[:,0]\n",
    "        y=p.get_bbox().get_points()[1,1]\n",
    "        ax1.annotate('{:.0f}'.format(p.get_height()), (x.mean(), y), ha='center', va='bottom')\n",
    "    \n",
    "    ax1.grid(False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Ситуация проясняется, комментарии с признаками класса \"severe_toxic\" абсолютно всегда размечаются и как \"toxic\". Более того, комментарии с признаками других классов тоже в подавляющем большинстве случаев размечаются и как \"toxic\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Длина комментария"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Влияет ли как-то длина комментария (в символах) на нормальность или недопустимость комментария?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train['length'] = train['comment_text'].apply(len)\n",
    "test['length'] = test['comment_text'].apply(len)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Посмотрим на комментарии с числом символов, к примеру, восемь:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train[train.length==8]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Два комментария из трех определенно неприемлимы для нормального общения. Рассмотрим этот признак визуально более глобально. Для начала взглянем на распределение признака:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(15,6))\n",
    "plt.suptitle(\"Распределение признака 'Длина комментария' в обучающей выборке\",fontsize=20)\n",
    "\n",
    "plt.subplot2grid((2,1),(0,0))\n",
    "plt.xlim(0, train.length.max())\n",
    "sns.distplot(train.length.values, hist=False, color=color[0], kde_kws={\"shade\": True, \"lw\": 2})\n",
    "plt.title(\"Количество символов\")\n",
    "\n",
    "plt.subplot2grid((2,1),(1,0))\n",
    "plt.xlim(0, train.length.max())\n",
    "sns.boxplot(train.length.values);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Максимальная длина комментария в выборке - 5000 символов. Причем основная масса комментариев имеет длину менее 1000 символов. Посмотрим на распределение этого же признака в тестовой выборке."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(15,6))\n",
    "plt.suptitle(\"Распределение признака 'Длина комментария' в тестовой выборке\",fontsize=20)\n",
    "\n",
    "plt.subplot2grid((2,1),(0,0))\n",
    "plt.xlim(0, test.length.max())\n",
    "sns.distplot(test.length.values, hist=False, color=color[0], kde_kws={\"shade\": True, \"lw\": 2})\n",
    "plt.title(\"Количество символов\")\n",
    "\n",
    "plt.subplot2grid((2,1),(1,0))\n",
    "plt.xlim(0, test.length.max())\n",
    "sns.boxplot(test.length.values);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Видим совершенно аналогичную ситуацию. Максимальная длина в 5000 символов говорит нам о том, что скорее всего была проведена дополнительная предобработка данных.<br>\n",
    "Сравним длину комментариев в нормальных комментариях и неприемлимых. Рассмотрим только комментарии с длиной менее 1000 символов. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(12,8))\n",
    "sns.violinplot(y=train['length'].loc[train['length']<1000],x=train.clean.map({0:'Нет', 1:'Да'}), data=train,split=True,inner=\"quart\")\n",
    "plt.xlabel('Нормальный комментарий?', fontsize=14)\n",
    "plt.ylabel('Число символов в комментарии', fontsize=14)\n",
    "plt.xticks(fontsize=11)\n",
    "plt.title(\"Распределение числа символов в зависимости от приемлимости комментария\", fontsize=15);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "На первый взгляд, неприемлимые комментарии более короткие и имеют медианное значение около 100 символов, в то время как нормальные комментарии имеют медианное значение почти 200 символов. Вообще, резонно предположить, что недопустимые комментарии не будут очень длинными. Писать целый трактат, чтобы кого-то оскорбить это по меньшей мере странно. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Топ 10 слов в классах комментариев"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Пришло время посмотреть, какие слова наиболее часто употребляют авторы недопустимых комментариев."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cv_train = CountVectorizer(ngram_range=(1, 1), max_features=1000, min_df=5, stop_words=stopwords.words('english'))\n",
    "X_train = cv_train.fit_transform(train.comment_text.values).toarray()\n",
    "\n",
    "top10_words_list=[]\n",
    "top10_freq_list=[]\n",
    "for col in y_cols:\n",
    "    top10_words = []\n",
    "    word_freq = X_train[train[col]==1].sum(axis=0)\n",
    "    top10_list = word_freq.argsort()[-10:][::-1]\n",
    "    for i in range(10):\n",
    "        top10_words.append(list(cv_train.vocabulary_.keys())[list(cv_train.vocabulary_.values()).index(top10_list[i])])\n",
    "    top10_words_list.append(top10_words)\n",
    "    top10_freq_list.append(sorted(word_freq, reverse=True)[:10])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, axes = plt.subplots(nrows=3, ncols=2, figsize=(16, 12))\n",
    "fig.suptitle('Топ-10 слов в каждом классе',fontsize = 18)\n",
    "\n",
    "for i, col in enumerate(y_cols): \n",
    "    temp_list = y_cols[:]\n",
    "    temp_list.remove(col)\n",
    "    ax1 = sns.barplot(top10_words_list[i], top10_freq_list[i], color=color[i+2], alpha=0.8, ax=axes[i // 2][i % 2])\n",
    "    ax1.tick_params(labelsize=10)\n",
    "    ax1.set_title(col+' ({} комментариев)'.format(train.loc[:,col].sum()), fontsize= 12)\n",
    "    ax1.set_ylabel('Количество употреблений в комментариях')\n",
    "    for p in ax1.patches:\n",
    "        x=p.get_bbox().get_points()[:,0]\n",
    "        y=p.get_bbox().get_points()[1,1]\n",
    "        ax1.annotate('{:.0f}'.format(p.get_height()), (x.mean(), y), ha='center', va='bottom')\n",
    "    \n",
    "    ax1.grid(False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Слово \"fuck\" лидирует во всех классах кроме комментариев, содержащих признаки угроз и личной неприязни. Харктерная особенность для этого слова в том, что в классе \"severe_toxic\" оно употребляется наиболее часто, в среднем 4 с лищним раза на один комментарий. Это много. В то же время слово \"die\" употребляется в среднем почти три раза в одном комментарии. В комментариях с признаками личной неприязни также есть свое слово-лидер - более двух раз на один комментарий. В то же время видно, что в топе есть и довольно нейтральные слова - wikipedia, like, go. Возможно, в дальнейшем их можно будет добавить в список стоп-слов."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Часть 4. Инсайты, найденные зависимости"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Подведем итог анализа данных:\n",
    "1. В данных обнаружились неанглоязычные комментарии. Это усложняет задачу, но можно будет использовать как дополнительный признак.\n",
    "2. Отсутствуют пропуски в данных\n",
    "3. Максимальная длина комментария в обучающей и тестовой выборках - 5000 символов. В то время как подавляющее большинство комментариев имеет не более 1000 символов.\n",
    "4. В данных сильный дисбаланс классов, это немного усложнит задачу, но в целом ничего страшного.\n",
    "5. Оскорбительные комментарии в среднем относятся одновременно к одному, двум, трем и реже четырем классам. Довольно мало комментариев, содержащих в себе признаки пяти и тем более шести классов.\n",
    "6. В процессе анализа данных обнаружился весьма хороший инсайт - нет ни одного комментария, относящегося только к одному классу \"severe_toxic\"\n",
    "7. Наибольшее количество комментариев с одним классом отнесены к классу \"toxic\"\n",
    "8. Комментарии имеющие признаки трех классов чаще всего относятся к: \"toxic\", \"insult\" и \"obscene\"\n",
    "9. Классы \"severe_toxic\" и \"identity_hate\" встречаются чаще всего в комментариях с признаками четырех классов\n",
    "10. Комментарии с признаками всех классов кроме \"toxic\" в подавляющем большинстве случаев размечаются и как \"toxic\". \n",
    "11. Медианное значение длины недопустимых комментариев меньше этого же значения нормальных комментариев примерно на 100 символов.\n",
    "12. Некоторые классы имеют свои характерные особенности - наиболее часто употребляемые слова. Это может быть хорошим признаком в дальнейшем."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Часть 5. Выбор метрики"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В задачах бинарной классификации наиболее часто используются следующие метрики качества в зависимости от решаемой задачи:\n",
    "\n",
    "- Доля правильных ответов (Accuracy)\n",
    "- Полнота (Recall)\n",
    "- Точность (Precision). \n",
    "- F-мера (F1-score). Среднее гармоническое точности и полноты.\n",
    "- Функция логистических потерь (LogLoss)\n",
    "- Площадь под ROC кривой (ROC-AUC)\n",
    "- Коэффициент Джини (Normalized Gini)\n",
    "\n",
    "Первые три метрики самые простые и оттого легко интерпретируемы, но имеют много минусов. И один из них - они совершенно не подходят для задач с сильным дисбалансом классов. Для нашей задачи наиболее подходят три последние метрики. Logloss сильно штрафует классификатор за уверенность в неверном ответе, так как максимизирует долю правильных ответов путем штрафа за неверные предсказания. Коэффициент Джини используется в основном в банковском секторе и страховании, это обусловлено тем, что в этой сфере в данных обычно сильнейший дисбаланс классов. Наиболее подходящая метрика для задачи - ROC-AUC. Она является отличным способом оценить предсказания вероятностей модели в целом, не привязываясь к конкретному порогу. \n",
    "\n",
    "Но мой индивидуальный проект подразумевает многоклассовую классификацию. В данном случае обычно используются два подхода:\n",
    "- микроусреднение\n",
    "- макроусреднение\n",
    "\n",
    "В первом случае на расчет метрики качества влияет вклад каждого класса в зависимости от его размера. Во втором случае рассчитывается метрика качества для каждого класса и потом усредняется, таким образом значение метрики не зависит от мощности класса. Второй класс наиболее подходит для решаемой задачи. Подводя итог, в задаче будет использоваться метрика качетва ROC-AUC с макроусреднением по классам. Именно таким образом рассчитывался итоговый результат в соревновании на Kaggle."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Часть 6. Выбор модели"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Так как в задаче используются текстовые данные, то очевидно, что матрица признаков будет сильно разреженной и иметь большую размерность. Количество признаков будет исчисляться десятками тысяч. Алгоритмы на основе деревьев решений очень долго и не всегда хорошо обучаются на таких данных. В то же время линейные модели прекрасно обучаются на таких данных и показывают отличные результаты. Классическими моделями в подобных задачах классификации являются:\n",
    "\n",
    "- LogisticRegression\n",
    "- SGDClassifier\n",
    "- Vowpal Wabbit\n",
    "\n",
    "Дополнительным плюсом этих моделей является то, что они отлично интерпретируемы и имеют гиперпараметры, которые можно подбирать на кросс-валидации. Последние две модели используются преимущественно на гигабайтах и терабайтах данных, что объясняется очень просто, обе они используют стохастический градиентный спуск при оптимизации. Однако на практике эти модели показывают обычно более худшие результаты, чем логистическая регрессия. Хотя теоретически можно подобрать гиперпараметры этих моделей, чтобы они не уступали в качестве логистической регрессии. Данные индивидуального проекта относительно небольшие и использование логистической регрессии представляется наилучшим выбором в этом случае."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Часть 7. Предобработка данных"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train = pd.read_csv('data/train.csv')\n",
    "test = pd.read_csv('data/test.csv')\n",
    "y_train = train[['toxic', 'severe_toxic', 'obscene', 'threat', 'insult', 'identity_hate']].values\n",
    "train.drop(['id', 'toxic', 'severe_toxic', 'obscene', 'threat', 'insult', 'identity_hate'], axis=1, inplace=True)\n",
    "test.drop('id', axis=1, inplace=True)\n",
    "y_cols = ['toxic', 'severe_toxic', 'obscene', 'threat', 'insult', 'identity_hate']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Итак, изначально в данных присутстует только один признак - текст комментария.\n",
    "Для преобразования текста будем использовать TfidfVectorizer из библиотеки Sklearn. TfidfVectorizer преобразует текст в матрицу TF-IDF. TF-IDF позволит оценить важность термина для какого-либо комментария относительно всех остальных комментариев. Принцип такой — если слово встречается в каком-либо комментарии часто, при этом встречаясь редко в остальных комментариях — это слово имеет большую значимость для этого комментария и соответственно классам, к которым этот комментарий относится. Слова, встречающиеся во многих комментариях, например, предлоги или междометия получат очень низкий вес TF-IDF (потому что часто встречаются во всех комментариях), а важные — высокий.\n",
    "Теперь кратко о том, как считается TF-IDF. TF - это частотность термина, которая измеряет, насколько часто термин встречается в документе. Логично предположить, что в длинных документах термин может встретиться в больших количествах, чем в коротких. Поэтому применяют относительные — делят количество раз, когда нужный термин встретился в тексте, на общее количество слов в тексте. В этом основное отличие от CountVectorizer. IDF — это обратная частотность документов. Она измеряет непосредственно важность термина. То есть, когда мы считаем TF, все термины считаются равными по важности друг другу. Но вполне очевидно, что, например, предлоги встречаются очень часто, хотя практически не влияют на смысл текста. IDF считается как логарифм от общего количества документов, делённого на количество документов, в которых встречается термин. И в конце TF умножается на IDF.\n",
    "Также, TfidfVectorizer имеет множество настроек:\n",
    "- минимальное и максимальное количнсвто n-грамм для анализа\n",
    "- максимальное число признаков\n",
    "- минимальное и максимальное число документов, в которых должно встретиться слово, чтобы попасть в признаки.\n",
    "- отключение расчета IDF\n",
    "- логарифмическое масштабирование значения TF\n",
    "- использование стоп-слов\n",
    "- приведение всех символов к нижнему регистру\n",
    "- нормализация токенов\n",
    "и многие другие\n",
    "\n",
    "И, пожалуй, один из основных плюсов - TfidfVectorizer имеет встроенный предобработчик текста, который задается в формате RegExp и его можно в любое время переопределить. По умолчанию удаляются знаки пунктуации, символы whitespace и берутся токены не меньше двух символов. Рассмотрим на примере случайного комментария, как TfidfVectorizer предобрабатывает текст.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "text = [train.sample(1).iloc[0, 0]]\n",
    "text"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Теперь обучим TfidfVectorizer и посмотрим на словарь. Так как комментарий один, то смысла в вычислении IDF нет, поэтому установим значение параметра use_idf в False."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cv = TfidfVectorizer(use_idf=False)\n",
    "X = cv.fit_transform(text)\n",
    "cv.get_feature_names()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Видно, что TfidfVectorizer отлично справился с задачей. Матрица TF-IDF:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X.toarray()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Сопоставим слова с их значениями TF-IDF (в данном случае только TF, так как комментарий один) и отсортируем по значениям TF в порядке убывания."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "matrix_freq = np.asarray(X.sum(axis=0)).ravel()\n",
    "dictionary = dict(zip(np.array(cv.get_feature_names()), matrix_freq))\n",
    "pprint.pprint(sorted(dictionary.items(), key=lambda x: x[1], reverse=True))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Слово \"and\" встречается чаще всего в комментарии и соответственно имеет наибольший вес. Слова \"back\", \"forth\" и \"you\" также встречаются более одного раза и имеют соответственно бОльшие веса. Слова, встречающиеся один раз в тексте имеют одинаковые веса. Но в вышеприведенном примере обрабатывается только один комментарий. В дальнейшем в словах, которые будут встречаться почти во всех комментариях, множитель IDF будет близок к нулю, что приведет к итоговому уменьшению значений весов у подобных слов. В этом вся прелесть и красота этой метрики. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Преобразуем весь корпус комментариев в обучающей и тестовой выборках. Важно не забывать, что обучать TfidfVectorizer необходимо только на обучающей выборке, потому что в реальной жизни тестовые данные не известны. Если обучить на всем корпусе комментариев, то легко может получиться так, что бОльшие веса будут у слов, которые при обучении только на обучающей выборке таких значений весов бы не получили. Работать будем с униграмами и максимальным значением признаков 30 000."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "cv = TfidfVectorizer(ngram_range=(1,1), max_features=30000)\n",
    "X_train = cv.fit_transform(train.comment_text)\n",
    "X_test = cv.transform(test.comment_text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Размер обучающей матрицы: {}'.format(X_train.shape))\n",
    "print('Размер тестовой матрицы: {}'.format(X_test.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Выведем снова значения весов слов для комментария, который рассматривали выше:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "idx = train[train.comment_text.str.contains('k. εαίδεια*')].index\n",
    "col_idx = np.nonzero(X_train[idx,:].toarray())[1]\n",
    "row = X_train[idx,:].toarray()\n",
    "word_values = row[row!=0]\n",
    "word_list = [list(cv.vocabulary_.keys())[list(cv.vocabulary_.values()).index(x)] for x in col_idx]\n",
    "dictionary = dict(zip(np.array(word_list), np.array(word_values)))\n",
    "pprint.pprint(sorted(dictionary.items(), key=lambda x: x[1], reverse=True))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ситуация сильно изменилась. Видно, что часто используемые в комментариях (да и в обычной жизни) слова имеют минимальные веса. Обычно, имеет смысл удалять такие слова на этапе препроцессинга. У этих слов есть определенный термин - стоп-слова, и в библиотеке sklearn есть их предопределенный набор. Посмотрим сколько слов содержит стоп-лист:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(ENGLISH_STOP_WORDS)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Добавим их и заново преобразуем корпус комментариев, для этого в TfidfVectorizer есть параметр \"stop_words\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "cv = TfidfVectorizer(ngram_range=(1,1), max_features=30000, stop_words='english')\n",
    "X_train = cv.fit_transform(train.comment_text)\n",
    "X_test = cv.transform(test.comment_text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Снова посмотрим значения весов слов для вышерассматриваемого комментария:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "idx = train[train.comment_text.str.contains('k. εαίδεια*')].index\n",
    "col_idx = np.nonzero(X_train[idx,:].toarray())[1]\n",
    "row = X_train[idx,:].toarray()\n",
    "word_values = row[row!=0]\n",
    "word_list = [list(cv.vocabulary_.keys())[list(cv.vocabulary_.values()).index(x)] for x in col_idx]\n",
    "dictionary = dict(zip(np.array(word_list), np.array(word_values)))\n",
    "pprint.pprint(sorted(dictionary.items(), key=lambda x: x[1], reverse=True))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Великолепный результат - из 29 слов осталось 12 значимых. Остался еще один момент - линейные алгоритмы очень любят, чтобы признаки были отмасштабированы. Значение TF-IDF теоретически может быть гораздо больше 1, но в TfidfVectorizer по умолчанию используется L2 нормализация (параметр \"norm\"), при которой все значения весов масштабируются на интервал [0; 1]. Проверим:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Максимальное значение TF-IDF: {}'.format(X_train.max()))\n",
    "print('Минимальное значение TF-IDF: {}'.format(X_train.min()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Выше рассматривалось, что пропусков в данных и выбросов нет."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Часть 8. Кросс-валидация и настройка гиперпараметров модели"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В третьей части проекта было показано, что целевая переменная имеет сильный дисбаланс по всем классам. Для кросс-валидации необходимо будет разбить обучающие данные таким образом, чтобы в каждом фолде было примерно одинаковое количество каждого из шести классов. Таким образом, необходимо провести стратифицированный отбор объектов из обучающей выборки по каждому вектору целевой переменной, чтобы в итоговых фолдах было примерно одинаковое количество всех шести классов. В sklearn не реализована такая возможность, поэтому внизу приведена кастомная функция для стратифицированной разбивки данных по фолдам. В данной реализации seed указывать нет необходимости, так как данная несложная задача оптимизации имеет аналитическое решение. Функция принимает на вход векторы целевой переменной (матрицу), количество необходимых фолдов и возвращает индексы объектов для каждого фолда. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def multi_label_split(y, folds=3):\n",
    "    obs, classes = y.shape\n",
    "    dist = y.sum(axis=0).astype('float')\n",
    "    dist /= dist.sum()\n",
    "    index_list = []\n",
    "    fold_dist = np.zeros((folds, classes), dtype='float')\n",
    "    for _ in range(folds):\n",
    "        index_list.append([])\n",
    "    for i in range(obs):\n",
    "        if i < folds:\n",
    "            target_fold = i\n",
    "        else:\n",
    "            normed_folds = fold_dist.T / fold_dist.sum(axis=1)\n",
    "            how_off = normed_folds.T - dist\n",
    "            target_fold = np.argmin(np.dot((y[i] - .5).reshape(1, -1), how_off.T))\n",
    "        fold_dist[target_fold] += y[i]\n",
    "        index_list[target_fold].append(i)\n",
    "    return index_list, fold_dist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Реализуем трехуровневую кросс-валидацию."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "index_list, fold_dist = multi_label_split(y=y_train, folds=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(18,5))\n",
    "plt.suptitle('Распределение классов по фолдам ({} объектов)'.format(len(train)),fontsize = 18)\n",
    "\n",
    "for i, fold in enumerate(fold_dist): \n",
    "    plt.subplot(131+i)\n",
    "    ax1 = sns.barplot(y_cols, fold, color=color[i+2], alpha=0.8)\n",
    "    ax1.set_title('Фолд {} ({} объектов)'.format(i+1, len(y_train[index_list[i]])), fontsize= 12)\n",
    "    ax1.set_ylabel('Количество объектов')\n",
    "    ax1.set_xlabel('Класс')\n",
    "    for p in ax1.patches:\n",
    "        x=p.get_bbox().get_points()[:,0]\n",
    "        y=p.get_bbox().get_points()[1,1]\n",
    "        ax1.annotate('{:.0f}'.format(p.get_height()), (x.mean(), y), ha='center', va='bottom')\n",
    "    ax1.grid(False);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Видно, что количество объектов и распределение классов во всех фолдах примерно одинаковое.\n",
    "Теперь необходимо реализовать функцию кросс-валидации. Здесь стоит остановиться на одном важном моменте. Необходимо будет заново преобразовывать обучающую и валидационную выборки в матрицы TF-IDF при каждом проходе по фолдам, чтобы избежать утечки данных и как следствие некорректного значения на кросс-валидации. На вход функция будет принимать следующие параметры:\n",
    "1. Модель для обучения и прогнозов\n",
    "2. Исходную обучающую выборку (это необходимо для того, чтобы в дальнейшем построить кривые обучения и валидации)\n",
    "3. Целевую переменную\n",
    "4. Список индексов фолдов, полученный в ранее реализованной функции multi_label_split. При каждом проходе один фолд будет выполнять роль тестовой выборки, а два других - обучающей.\n",
    "5. Параметры TfidfVectorizer\n",
    "6. Параметр verbose - отображать или нет значения ROC-AUC классов в каждом фолде\n",
    "\n",
    "На выходе функция будет возвращать среднее значение ROC-AUC значений по фолдам. На каждом проходе модель обучается шесть раз на каждом классе целевой переменной и каждый раз рассчитывается значение ROC-AUC для прогнозов по каждому классу, потом эти шесть значений усредняются (макроусреднение, как описывалось выше). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def multi_label_cv(model, X, y, index_list, tfidf_params, verbose=True, add_feats=False):\n",
    "    roc_auc_folds = []\n",
    "    for i in range(3):\n",
    "        print('========== FOLD {} =========='.format(i+1))\n",
    "        X_tr = X.values[list(set(range(len(y)))-set(index_list[i])), :]\n",
    "        y_tr = y[list(set(range(len(y)))-set(index_list[i])), :]\n",
    "        X_val, y_val = X.values[index_list[i], :], y[index_list[i], :]\n",
    "\n",
    "        cv = TfidfVectorizer(**tfidf_params)\n",
    "        X_tr_csr = cv.fit_transform(X_tr.ravel())\n",
    "        X_val_csr = cv.transform(X_val.ravel())\n",
    "\n",
    "        roc_auc_scores = []\n",
    "        preds_val = np.zeros((y_val.shape[0], 6))\n",
    "        for i in range (6):\n",
    "            print('class: {}, '.format(y_cols[i]), end=\" \")\n",
    "            model.fit(X_tr_csr, y_tr[:,i])\n",
    "            preds_val[:,i] = model.predict_proba(X_val_csr)[:,1]\n",
    "            roc_auc_scores.append(roc_auc_score(y_val[:,i], preds_val[:,i]))\n",
    "            if verbose:\n",
    "                print('ROC-AUC score: ', roc_auc_scores[i])\n",
    "\n",
    "        print('mean ROC-AUC score by fold: ', np.mean(roc_auc_scores))\n",
    "        roc_auc_folds.append(np.mean(roc_auc_scores))\n",
    "\n",
    "    print('\\nMEAN ROC-AUС score: ', np.mean(roc_auc_folds))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Гиперпараметры модели"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Логистическая регрессия (LogisticRegression) имеет следующие основные гиперпараметры:\n",
    "1. <b>solver</b> (\"newton-cg\", \"lbfgs\", \"liblinear\", \"sag\", \"saga\") – алгоритм, который используется для решения задачи оптимизации. Для небольших данных обычно используется \"liblinear\". Остальные алгоритмы используются либо для больших данных, либо для решения задачи оптимизации в случае, когда целевая переменная представляет собой один мультиклассовый вектор (multinomial). В нашем случае используется схема мультиклассовой классификации one-versus-rest, для которой идельно подходит алгоритм liblinear.\n",
    "2. <b>C</b> - коэффициент регуляризации. Чем меньше значение данного коэффициента, тем сильнее регуляризация. Значение данного гиперпараметра будет настроено позже, после после создания новых признаков. В данной части берется значение по умолчанию, равное единице.\n",
    "3. <b>penalty</b> (L1 или L2) - тип регуляризации. По умолчанию используется L2-регуляризация, в то время, как нам, возможно, будет полезен L1-тип регуляризации. Этот гиперпараметр также будет настроен на кросс-валидации после построения новых признаков.\n",
    "4. <b>class_weight</b> - очень важный гиперпараметр в контексте решения данной задачи. Используется при дисбалансе классов. Сразу выставим его значение True.\n",
    "5. <b>random_state</b> - используется для воспроизводимости результатов. Укажем значение равное 1.\n",
    "6. <b>dual</b> - прямая или дуальная задача оптимизации. Иммет смысл использовать только если количество признаков превышает количество объектов. \n",
    "7. <b>tol, max_iter</b> - параметры раннего останова алгоритма оптимизации, используются только в алгоритмах  newton-cg, sag и lbfgs\n",
    "8. <b>multi_class</b> - multinominal или ovr. В данной задаче реализуется схема мультиклассовой классификации one-versus-rest, что соответствует значению по умолчанию\n",
    "9. <b>fit_intercept</b> - определяет добавлять ли константный коэффициент. По умолчанию True, что соответствует задаче."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lr_params={'C': 1.0,\n",
    "           'solver': 'liblinear', \n",
    "           'penalty': 'l2',\n",
    "           'class_weight': 'balanced',\n",
    "           'random_state': 1,\n",
    "           }\n",
    "\n",
    "lr = LogisticRegression(**lr_params)\n",
    "\n",
    "tfidf_params={'ngram_range': (1,1),\n",
    "              'max_features': 30000, \n",
    "              'stop_words': 'english'\n",
    "              }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "multi_label_cv(lr, train, y_train, index_list, tfidf_params=tfidf_params)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Алгоритм показывает довольно хорошие результаты.\n",
    "В данной части была реализована модель кросс-валидации и выбраны гиперпараметры модели LogisticRegression. Значения параметров \"С\" и \"penalty\" будут подобраны на кросс-валидации в следующей части после создания признаков."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Часть 9. Создание новых признаков и описание этого процесса"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ранее выдвигались следующие предположения:\n",
    "1. Нормальные комментарии в среднем длиннее оскорбительных, поэтому можно создать признак \"длина комментария в символах\"\n",
    "2. Довольно часто в реальной жизни при хамском общении люди часто используют капслок в комментариях. Есть даже такой термин \"кричать капслоком\". На основании этого можно посчитать частоту символов в верхнем регистре относительно общего числа символов в комментарии. Как таковое абсолютное значение числа символов в верхнем регистре будет бессмысленно из-за того, что комментарии имеют разную длину от 1 до 5000 символов.\n",
    "3. Очевидно, что в интернете, когда люди оскорбляют кого-то, то используют восклицательные знаки (аналогично крику в реальной жизни). На основании данного предположения можно посчитать частоту восклицательных знаков в тексте комментария.\n",
    "4. Можно выдвинуть гипотезу, что комментарии, содержащие символ \\*, скорее всего оскорбительного характера. Обычно люди не употребляют этот символ при написании текста, но если собираются написать неприличное слово, то какую-нибудь букву в нем скорее всего заменят на этот символ. Либо пользователь догадывается или знает, что комментарии автоматически модерируются и специально поставит \\*, чтобы выйти из паттерна.\n",
    "5. Признаковое пространство слов. Можно будет подобрать на кросс-валидации оптимальное число признаков , дающее лучший результат на обучении.\n",
    "\n",
    "После создания новых признаков необходимо будет подобрать гиперпараметры модели LogisticRegression"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Признак \"Длина комментария в символах\"\n",
    "\n",
    "Создадим отдельный датафрейм, который в дальнейшем будет содержать дополнительные добавляемые признаки и создадим признак \"длина комментария в символах\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "feats_train = pd.DataFrame()\n",
    "feats_train['length'] = train['comment_text'].apply(len)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "feats_train.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Значения признака находятся в интервале [1, 5000], как было показано ранее. Это не подходит для модели LogisticRegression, поэтому значения необходимо будет отмасштабировать. Причем делать это необходимо будет при каждом проходе по фолдам, чтобы не было утечки данных. Для этого доработаем функцию кросс-валидации. В ней добавятся еще два параметра:\n",
    "- X_f - датафрейм с дополнительными признаками. \n",
    "- scale_cols - масштабируемые признаки\n",
    "\n",
    "Датафрейм с дополнительными признаками также разбивается по индексам и необходимые признаки масштабируются. Далее матрицы объединяются с помощью функции hstack."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def multi_label_cv(model, X, y, index_list, tfidf_params, X_f, scale_cols, verbose=True):\n",
    "    roc_auc_folds = []\n",
    "    for fold in range(3):\n",
    "        if verbose:\n",
    "            print('========== FOLD {} =========='.format(fold+1))\n",
    "        trn_idx = list(set(range(len(y)))-set(index_list[fold]))\n",
    "        X_tr = X.values[trn_idx, :]\n",
    "        y_tr = y[trn_idx, :]\n",
    "        X_val, y_val = X.values[index_list[fold], :], y[index_list[fold], :]\n",
    "        X_tr_f = X_f.iloc[trn_idx, :]\n",
    "        X_val_f = X_f.iloc[index_list[fold], :]\n",
    "\n",
    "        cv = TfidfVectorizer(**tfidf_params)\n",
    "        X_t_csr = cv.fit_transform(X_tr.ravel())\n",
    "        X_v_csr = cv.transform(X_val.ravel())  \n",
    "        \n",
    "        scaler = StandardScaler()\n",
    "        X_tr_f[scale_cols] = scaler.fit_transform(X_tr_f[scale_cols].values)\n",
    "        X_val_f[scale_cols] = scaler.transform(X_val_f[scale_cols].values)\n",
    "        \n",
    "        X_tr_csr = hstack([X_t_csr, X_tr_f])\n",
    "        X_val_csr = hstack([X_v_csr, X_val_f])\n",
    "\n",
    "        roc_auc_scores = []\n",
    "        preds_val = np.zeros((y_val.shape[0], 6))\n",
    "        for i in range (6):\n",
    "            model.fit(X_tr_csr, y_tr[:,i])\n",
    "            preds_val[:,i] = model.predict_proba(X_val_csr)[:,1]\n",
    "            roc_auc_scores.append(roc_auc_score(y_val[:,i], preds_val[:,i]))\n",
    "            if verbose:\n",
    "                print('class: {}, '.format(y_cols[i]), end=\" \")\n",
    "                print('ROC-AUC score: ', roc_auc_scores[i])\n",
    "        if verbose:\n",
    "            print('mean ROC-AUC score by fold: ', np.mean(roc_auc_scores))\n",
    "        roc_auc_folds.append(np.mean(roc_auc_scores))\n",
    "\n",
    "    print('\\nMEAN ROC-AUС score: {:.6f}\\n'.format(np.mean(roc_auc_folds)))\n",
    "    return np.mean(roc_auc_folds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "_ = multi_label_cv(lr, train, y_train, index_list, tfidf_params=tfidf_params, X_f=feats_train, \n",
    "               scale_cols=['length'], verbose=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Значения ROC-AUC улучшились. Добавим теперь признак \"Доля символов в верхнем регистре\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Признак \"Доля символов в верхнем регистре в комментарии\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для подсчета доли символов в верхнем регистре удобно воспользоваться библиотекой регулярных выражений re:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "feats_train['upper_case_ratio'] = train['comment_text'].apply(lambda x: \\\n",
    "                                                              len(re.findall(r'[A-Z]',x))/(len(re.findall(r'[A-Za-z]',x))+1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "feats_train.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Очевидно, что данные значения всегда будут меньше или равны единице, следовательно масштабировать данный признак не надо."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "_ = multi_label_cv(lr, train, y_train, index_list, tfidf_params=tfidf_params, X_f=feats_train, \n",
    "               scale_cols=['length'], verbose=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Значение метрики снова улучшилось."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Признак \"Доля восклицательных знаков\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "feats_train['exclamation_point'] = train['comment_text'].apply(lambda x: x.count('!')/len(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "feats_train.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В данном случае значения также всегда будут меньше или равны единице, следовательно масштабировать данный признак не надо."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "_ = multi_label_cv(lr, train, y_train, index_list, tfidf_params=tfidf_params, X_f=feats_train, \n",
    "               scale_cols=['length'], verbose=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Значение метрики ROC-AUC на кросс-валидации в очередной раз улучшилось."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Признак \"Символ * в комментарии\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Данный признак будет бинарный:<br><br>\n",
    "1 - в комментарии присутствует символ\\*<br>\n",
    "0 - в комментарии отсутствует символ \\*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "feats_train['asterix'] = train['comment_text'].apply(lambda x: 1 if x.count('*')>0 else 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "feats_train.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "_ = multi_label_cv(lr, train, y_train, index_list, tfidf_params=tfidf_params, X_f=feats_train, \n",
    "               scale_cols=['length'], verbose=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Гипотеза оказалась верна и значение средней величины ROC-AUC на кросс-валидации улучшилось."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Настройка параметров TfidfVectorizer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Признаковое пространство**<br>\n",
    "В цикле будем вызывать функцию кросс-валидации, передавая в TfidfVectorizer различные значения параметра 'max_features' (максимальное число признаков-слов). Параметр будет принимать значения от 10 000 до 100 000 с шагом 10 000."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "scores=[]\n",
    "for num_feats in range(10000,110000,10000):\n",
    "    tfidf_params={'ngram_range': (1,1),\n",
    "                  'max_features': num_feats, \n",
    "                  'stop_words': 'english'\n",
    "                  }\n",
    "    print('max_features = {}'.format(num_feats))\n",
    "    score = multi_label_cv(lr, train, y_train, index_list, tfidf_params=tfidf_params, X_f=feats_train, \n",
    "                   scale_cols=['length'], verbose=False)    \n",
    "    scores.append(score)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Построим график зависимости значения ROC-AUC от числа признаков-слов."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(10,6))\n",
    "plt.plot(list(range(10000,110000,10000)), scores)\n",
    "plt.ylabel('Среднее ROC-AUC на кросс-валидации', fontsize=12)\n",
    "plt.xlabel('Количество признаков (max_features)', fontsize=12);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Хорошо видно, что примерно при 80 000 признаков значение выходит на плато. В дальнейшем будем использовать данное значение для параметра max_features."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Параметр sublinear_tf**<br>\n",
    "Данный параметр преобразует значение TF в логарифмической шкале и рассчитывается по формуле tf = 1 + log(tf), если tf>0. Смысл этого параметра в том, что значение TF быстро растет при маленьких значениях (слово нечасто встречается в документе) и медленно - при больших значениях (слово часто встречается в документе). По умолчанию равен False. Также в цикле будем вызывать функцию кросс-валидации, передавая в TfidfVectorizer различные значения параметра."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "scores=[]\n",
    "for param in [True, False]:\n",
    "    tfidf_params={'ngram_range': (1,1),\n",
    "                  'max_features': 80000, \n",
    "                  'stop_words': 'english',\n",
    "                  'sublinear_tf': param\n",
    "                  }\n",
    "    print('sublinear_tf = {}'.format(param))\n",
    "    score = multi_label_cv(lr, train, y_train, index_list, tfidf_params=tfidf_params, X_f=feats_train, \n",
    "                   scale_cols=['length'], verbose=False)    \n",
    "    scores.append(score)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "При сглаживании значения TF значение ROC-AUC ощутимо повышается.\n",
    "Зафиксируем окончательные значения параметров TfidfVectorizer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tfidf_params={'ngram_range': (1,1),\n",
    "              'max_features': 80000, \n",
    "              'stop_words': 'english',\n",
    "              'sublinear_tf': True\n",
    "                  }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Настройка гиперпараметров модели"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Осталось подобрать значения гиперпараметров модели. Аналогично в цикле будем вызывать функцию кросс-валидации, передавая в неё модель с различными параметрами. Параметры TfidfVectorizer уже подобраны и их не меняем. Для начала сравним значения при рахных регуляризациях (l1 и l2), а также сделаем предварительную оценку лучшего значения коэффициента регуляризации. Более точно лучшее значение выберем в следующей части при построении кривых валидации."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "scores=[]\n",
    "for i in ['l2', 'l1']:\n",
    "       \n",
    "    lr_params={'C': 1.0,\n",
    "           'solver': 'liblinear', \n",
    "           'penalty': i,\n",
    "           'class_weight': 'balanced',\n",
    "           'random_state': 1,\n",
    "           }\n",
    "    print('penalty = {}'.format(i))\n",
    "    lr = LogisticRegression(**lr_params)\n",
    "    score = multi_label_cv(lr, train, y_train, index_list, tfidf_params=tfidf_params, X_f=feats_train, \n",
    "                   scale_cols=['length'], verbose=False)    \n",
    "    scores.append(score)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Результаты при  использовании l2-регуляризации значительно лучше"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "scores=[]\n",
    "\n",
    "for i in [0.5, 1.0, 2.0, 3.0, 4.0]:\n",
    "        \n",
    "    lr_params={'C': i,\n",
    "           'solver': 'liblinear', \n",
    "           'penalty': 'l2',\n",
    "           'class_weight': 'balanced',\n",
    "           'random_state': 1,\n",
    "           }\n",
    "    print('С = {}'.format(i))\n",
    "    lr = LogisticRegression(**lr_params)\n",
    "    score = multi_label_cv(lr, train, y_train, index_list, tfidf_params=tfidf_params, X_f=feats_train, \n",
    "                   scale_cols=['length'], verbose=False)    \n",
    "    scores.append(score)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Построим график зависимости значения ROC-AUC от значения коэффициента регуляризации."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(10,6))\n",
    "plt.plot([0.5, 1.0, 2.0, 3.0, 4.0], scores)\n",
    "plt.ylabel('Среднее ROC-AUC на кросс-валидации', fontsize=12)\n",
    "plt.xlabel('С', fontsize=12);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Лучшее значение коэффициента регуляризации С предположительно лежит в интервале (0.5. 2.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Часть 10. Построение кривых валидации и обучения"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Модифицируем функцию кросс-валидации так, чтобы она возвращала следующие значения:\n",
    "- среднее значение ROC-AUC на обучающей выборке\n",
    "- среднее значение ROC-AUC на тестовой выборке\n",
    "- стандартное отклонение значения ROC-AUC на обучающей выборке\n",
    "- стандартное отклонение значения ROC-AUC на тестовой выборке"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def multi_label_cv(model, X, y, index_list, tfidf_params, X_f, scale_cols, verbose=True):\n",
    "    roc_auc_folds_val = []\n",
    "    roc_auc_folds_tr = []\n",
    "    for fold in range(3):\n",
    "        if verbose:\n",
    "            print('========== FOLD {} =========='.format(fold+1))\n",
    "        trn_idx = list(set(range(len(y)))-set(index_list[fold]))\n",
    "        X_tr = X.values[trn_idx, :]\n",
    "        y_tr = y[trn_idx, :]\n",
    "        X_val, y_val = X.values[index_list[fold], :], y[index_list[fold], :]\n",
    "        X_tr_f = X_f.iloc[trn_idx, :]\n",
    "        X_val_f = X_f.iloc[index_list[fold], :]\n",
    "\n",
    "        cv = TfidfVectorizer(**tfidf_params)\n",
    "        X_t_csr = cv.fit_transform(X_tr.ravel())\n",
    "        X_v_csr = cv.transform(X_val.ravel())  \n",
    "        \n",
    "        scaler = StandardScaler()\n",
    "        X_tr_f[scale_cols] = scaler.fit_transform(X_tr_f[scale_cols].values)\n",
    "        X_val_f[scale_cols] = scaler.transform(X_val_f[scale_cols].values)\n",
    "        \n",
    "        X_tr_csr = hstack([X_t_csr, X_tr_f])\n",
    "        X_val_csr = hstack([X_v_csr, X_val_f])\n",
    "\n",
    "        roc_auc_scores_val = []\n",
    "        roc_auc_scores_tr = []\n",
    "        preds_val = np.zeros((y_val.shape[0], 6))\n",
    "        preds_tr = np.zeros((y_tr.shape[0], 6))\n",
    "        for i in range (6):\n",
    "            model.fit(X_tr_csr, y_tr[:,i])\n",
    "            preds_val[:,i] = model.predict_proba(X_val_csr)[:,1]\n",
    "            preds_tr[:,i] = model.predict_proba(X_tr_csr)[:,1]\n",
    "            roc_auc_scores_val.append(roc_auc_score(y_val[:,i], preds_val[:,i]))\n",
    "            roc_auc_scores_tr.append(roc_auc_score(y_tr[:,i], preds_tr[:,i]))\n",
    "            if verbose:\n",
    "                print('class: {}, '.format(y_cols[i]), end=\" \")\n",
    "                print('ROC-AUC score: ', roc_auc_scores[i])\n",
    "        if verbose:\n",
    "            print('mean ROC-AUC score by fold: ', np.mean(roc_auc_scores))\n",
    "        roc_auc_folds_val.append(np.mean(roc_auc_scores_val))\n",
    "        roc_auc_folds_tr.append(np.mean(roc_auc_scores_tr))\n",
    "\n",
    "    print('\\nMEAN ROC-AUС score: {:.6f}\\n'.format(np.mean(roc_auc_folds_val)))\n",
    "    return np.mean(roc_auc_folds_tr), np.std(roc_auc_folds_tr), np.mean(roc_auc_folds_val), np.std(roc_auc_folds_val)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Вспомогательные функции для отрисовки кривых валидации и обучения"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_validation_curves(param_values, train_mu, train_std, valid_mu, valid_std):\n",
    "    train_line = plt.plot(param_values, train_mu, '-', label='train', color='green')\n",
    "    valid_line = plt.plot(param_values, valid_mu, '-', label='test', color='red')\n",
    "    plt.fill_between(param_values, np.array(train_mu) - np.array(train_std), \n",
    "                     np.array(train_mu) + np.array(train_std), edgecolor='none',\n",
    "                     facecolor=train_line[0].get_color(), alpha=0.2)\n",
    "    plt.fill_between(param_values, np.array(valid_mu) - np.array(valid_std), \n",
    "                     np.array(valid_mu) + np.array(valid_std), edgecolor='none',\n",
    "                     facecolor=valid_line[0].get_color(), alpha=0.2)\n",
    "    plt.legend()\n",
    "    \n",
    "def plot_learning_curve(train_sizes, train_mu, train_std, valid_mu, valid_std):\n",
    "    train_line = plt.plot(train_sizes, train_mu, '-', label='train', color='green')\n",
    "    valid_line = plt.plot(train_sizes, valid_mu, '-', label='test', color='red')\n",
    "    plt.fill_between(train_sizes, np.array(train_mu) - np.array(train_std), \n",
    "                     np.array(train_mu) + np.array(train_std), edgecolor='none',\n",
    "                     facecolor=train_line[0].get_color(), alpha=0.2)\n",
    "    plt.fill_between(train_sizes, np.array(valid_mu) - np.array(valid_std), \n",
    "                     np.array(valid_mu) + np.array(valid_std), edgecolor='none',\n",
    "                     facecolor=valid_line[0].get_color(), alpha=0.2)\n",
    "    plt.xlabel('Размер обучающей выборки'); \n",
    "    plt.ylabel('ROC-AUC')\n",
    "    plt.legend(loc='lower right');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Кривые валидации"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Подберем значение коэффициента регуляризации более точно с помощью кривых валидации. Будем перебирать 20 значений от 0.5 до 2.0. Для каждого значения рассчитываются средние значения ROC-AUC на обучающей и тестовой выборках, а также их стандартные отклонения."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "mean_scores_train=[]\n",
    "std_scores_train=[]\n",
    "mean_scores_val=[]\n",
    "std_scores_val=[]\n",
    "Cs = np.linspace(0.5, 2.0, 20)\n",
    "\n",
    "for i in Cs:\n",
    "        \n",
    "    lr_params={'C': i,\n",
    "           'solver': 'liblinear', \n",
    "           'penalty': 'l2',\n",
    "           'class_weight': 'balanced',\n",
    "           'random_state': 1,\n",
    "           }\n",
    "    print('С = {}'.format(i))\n",
    "    lr = LogisticRegression(**lr_params)\n",
    "    mean_score_tr, std_score_tr, mean_score_val, std_score_val = multi_label_cv(lr, train, y_train, \n",
    "                        index_list, tfidf_params=tfidf_params, X_f=feats_train, scale_cols=['length'], verbose=False)    \n",
    "    mean_scores_train.append(mean_score_tr)\n",
    "    std_scores_train.append(std_score_tr)\n",
    "    mean_scores_val.append(mean_score_val)\n",
    "    std_scores_val.append(std_score_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Лучшее значение ROC AUC = {:.6f}, при С = {:.6f}'.format(max(mean_scores_val), \n",
    "                                                                Cs[mean_scores_val.index(max(mean_scores_val))]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Построим кривые валидации:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(10,6))\n",
    "Cs_plot = [round(x,2) for x in Cs]\n",
    "plot_validation_curves(Cs_plot, mean_scores_train, std_scores_train, mean_scores_val, std_scores_val)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Валидационная кривая:\n",
    "\n",
    "Кривые валидации находятся близко друг другу и имеют высокое значение ROC-AUC в масштабах возможных изменений значений (0.5 - 1). Если бы значение ROC-AUC было бы довольно низкое, в то время как кривые находились бы рядом - это говорило бы о недообучении модели. При переобучении тренировочная и валидационная ошибки значительно бы отличались (не хватало бы регуляризации). В нашем случае при значении коэффициента регуляризации примерно равным 0.736842 модель показывает наилучшие результаты. При увеличении коэффициента (то есть снижении регуляризации, так как коэффициент равен 1/lambda) больше этого значения модель начинает переобучаться. При значениях коэффициента меньше этого значения (увеличение регуляризации) регуляризация избыточно сильная, модель недообучается."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Зафиксируем лучшее значение С в параметрах модели:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lr_params={'C': 0.73684,\n",
    "           'solver': 'liblinear', \n",
    "           'penalty': 'l2',\n",
    "           'class_weight': 'balanced',\n",
    "           'random_state': 1,\n",
    "           }\n",
    "lr = LogisticRegression(**lr_params)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Кривые обучения"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "С помощью кривых обучения можно проверить следующую гипотезу - действительно ли у нас достаточно данных. Можно ли улучшить качество модели, взяв больше данных? Это легко проверяется, если значение метрики на валидации сначала повышается и потом в какой-то момент выходит \"на плато\", то данных достаточно. Если же значение метрики даже при максимально доступном размере данных продолжает увеличиваться, то данных явно недостаточно для выявления закономерностей. В данном случае необходимо увеличить размер обучающей выборки, если это возможно."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для построения кривых обучения используется ранее написанная функция multi_label_split. Минимальный размер выборки - 5% (примерно 5000 комментариев) от обучающей выборки, максимальный размер - вся обучающая выборка. На каждом проходе выборка разбивается на три фолда. таким образом, размер обучающей выборки определяется как произведение размера текущей выборки на 2/3. Также берется 18 промежуточных размеров. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "mean_scores_train=[]\n",
    "std_scores_train=[]\n",
    "mean_scores_val=[]\n",
    "std_scores_val=[]\n",
    "n_trains=[]\n",
    "train_sizes = np.linspace(0.05, 1, 20)\n",
    "n_train = len(y_train)*train_sizes\n",
    "\n",
    "for num, size in enumerate(train_sizes):\n",
    "    \n",
    "    n_trains.append(int(n_train[num]))\n",
    "    print('Размер выборки = {}'.format(int(n_trains[num]/3*2)))\n",
    "    index_list, fold_dist = multi_label_split(y=y_train[:n_trains[num], :], folds=3)\n",
    "    mean_score_tr, std_score_tr, mean_score_val, std_score_val = multi_label_cv(lr, train, y_train, \n",
    "                        index_list, tfidf_params=tfidf_params, X_f=feats_train, scale_cols=['length'], verbose=False)    \n",
    "    mean_scores_train.append(mean_score_tr)\n",
    "    std_scores_train.append(std_score_tr)\n",
    "    mean_scores_val.append(mean_score_val)\n",
    "    std_scores_val.append(std_score_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(10,6))\n",
    "plot_learning_curve([int(x/3*2) for x in n_train.tolist()], mean_scores_train, std_scores_train, mean_scores_val, std_scores_val)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Видно, что в какой-то момент кривые сходятся и кривая валидации тестовой выборки выходит на плато. Данных явно достаточно для выявления закономерностей. Увеличение размера выборки не даст ощутимого прироста качества."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Часть 11. Прогноз для тестовой выборки"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Сделаем прогноз для тестовой выборки. Для этого загрузим образец файла для прогнозных значений и в соответствующем формате сохраним наши прогнозы. После этого загрузим файл с прогнозами на Kaggle. Результат на LB будет значением ROC-AUC для тестовой выборки. Для прогноза будем использовать гиперпараметры настроенные на кросс-валидации и такое же признаковое пространство."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "submission = pd.read_csv('data/sample_submission.csv')\n",
    "feats_test = pd.DataFrame()\n",
    "feats_test['length'] = test['comment_text'].apply(len)\n",
    "feats_test['upper_case_ratio'] = test['comment_text'].apply(lambda x: \\\n",
    "                                                            len(re.findall(r'[A-Z]',x))/(len(re.findall(r'[A-Za-z]',x))+1))\n",
    "feats_test['exclamation_point'] = test['comment_text'].apply(lambda x: x.count('!')/len(x))\n",
    "feats_test['asterix'] = test['comment_text'].apply(lambda x: 1 if x.count('*')>0 else 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tfidf_params={'ngram_range': (1,1),\n",
    "              'max_features': 80000, \n",
    "              'stop_words': 'english',\n",
    "              'sublinear_tf': True\n",
    "                  }\n",
    "lr_params={'C': 0.73684,\n",
    "           'solver': 'liblinear', \n",
    "           'penalty': 'l2',\n",
    "           'class_weight': 'balanced',\n",
    "           'random_state': 1,\n",
    "           }\n",
    "lr = LogisticRegression(**lr_params)\n",
    "cv = TfidfVectorizer(**tfidf_params)\n",
    "\n",
    "X_train_csr = cv.fit_transform(train['comment_text'])\n",
    "X_test_csr = cv.transform(test['comment_text'])  \n",
    "        \n",
    "scaler = StandardScaler()\n",
    "feats_train['length'] = scaler.fit_transform(feats_train[['length']])\n",
    "feats_test['length'] = scaler.transform(feats_test[['length']])\n",
    "        \n",
    "X_train = hstack([X_train_csr, feats_train.values])\n",
    "X_test = hstack([X_test_csr, feats_test.values])\n",
    "\n",
    "preds = np.zeros((test.shape[0], 6))\n",
    "for i in range (6):\n",
    "    lr.fit(X_train, y_train[:,i])\n",
    "    preds[:,i] = lr.predict_proba(X_test)[:,1]\n",
    "\n",
    "submission[[\"toxic\", \"severe_toxic\", \"obscene\", \"threat\", \"insult\", \"identity_hate\"]] = preds\n",
    "submission.to_csv('submission.csv', index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Результат на LB:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "im = Image.open('data/place.png')\n",
    "im"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Получили довольно хороший результат, тем более для единственного прогноза в соревновании.\n",
    "Также хорошо видно, что не произошло переобучения на Private Liderboard. В то же время значение ROC-AUC для тестовой выборки соотносится со значением на кросс-валидации. Можно сделать вывод о том, что модель имеет хорошее качество."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Часть 12. Выводы"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Построена модель, которая имеет хорошую обобщающую способность. Грамотно выбрана сама модель, проведена корректная кросс-валидация, на которой проверена значимость новых признаков и настроены гиперпараметры модели. Ценность модели заключается в том, что ее можно использовать для любого другого сервиса помимо Википедии. Автоматически модерировать нежелательные комментарии, что позволит улучшить качество общения пользователей и повысить конструктивность диалогов на образовательных сайтах.\n",
    "\n",
    "В части путей улучшения, можно использовать следующие направления:\n",
    "\n",
    "- Кластеризовать комментарии по языку.\n",
    "- Добавить новые признаки.\n",
    "- Использовать стемминг слов.\n",
    "- Использовать лемматизацию слов.\n",
    "- Добавить биграммы и триграммы.\n",
    "- Добавить в список стоп-слов, слова характерные для платформы Википедия\n",
    "- Использовать байесовский подход.\n",
    "- Создать ансамбль моделей.\n",
    "\n",
    "Задачи NLP хороши и интересны тем, что существует бесконечное множество путей, куда можно двигаться дальше, чтобы повысить качество решения задачи."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
